// HerosBondController.java
package com.geek.hero.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.geek.hero.entity.Bond;
import com.geek.hero.entity.Heros;
import com.geek.hero.entity.HerosBond;
import com.geek.hero.result.Result;
import com.geek.hero.service.IBondService;
import com.geek.hero.service.IHerosBondService;
import com.geek.hero.service.IHerosService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * <p>
 * 英雄羁绊关系 前端控制器
 * </p>
 *
 * @author author
 * @since 2025-09-14
 */
@RestController
@RequestMapping("/heros-bond")
@CrossOrigin
public class HerosBondController {

    // 注入英雄羁绊关系服务
    @Autowired
    private IHerosBondService herosBondService;

    // 注入英雄服务
    @Autowired
    private IHerosService herosService;

    // 注入羁绊服务
    @Autowired
    private IBondService bondService;

    /**
     * 获取所有英雄羁绊关系
     * 请求路径: GET /heros-bond
     * @return Result 包含所有英雄羁绊关系列表
     */
    @GetMapping
    public Result list() {
        List<HerosBond> list = herosBondService.list();
        return new Result(true, "查询成功", list);
    }

    /**
     * 根据英雄ID获取羁绊信息
     * 请求路径: GET /heros-bond/hero/{heroId}
     * @param heroId 英雄ID
     * @return Result 包含指定英雄的所有羁绊信息
     */
    @GetMapping("/hero/{heroId}")
    public Result getByHeroId(@PathVariable Integer heroId) {
        try {
            // 查询该英雄的所有羁绊关系
            List<HerosBond> herosBonds = herosBondService.list(
                    new QueryWrapper<HerosBond>().eq("hero_id", heroId)
            );

            // 构造返回结果
            List<Map<String, Object>> bondsInfo = new ArrayList<>();
            for (HerosBond herosBond : herosBonds) {
                // 根据羁绊ID获取羁绊详细信息
                Bond bond = bondService.getById(herosBond.getBondId());
                if (bond != null) {
                    Map<String, Object> bondInfo = new HashMap<>();
                    bondInfo.put("bond_id", bond.getId());      // 羁绊ID
                    bondInfo.put("name", bond.getName());       // 羁绊名称
                    bondInfo.put("miaoshu", bond.getMiaoshu()); // 羁绊描述信息
                    bondInfo.put("xiaoguo", bond.getXiaoguo()); // 羁绊效果信息
                    bondsInfo.add(bondInfo);
                }
            }

            return new Result(true, "查询成功", bondsInfo);
        } catch (Exception e) {
            // 捕获异常并返回错误信息
            return new Result(false, "查询失败: " + e.getMessage());
        }
    }

    /**
     * 根据羁绊ID获取英雄关系
     * 请求路径: GET /heros-bond/bond/{bondId}
     * @param bondId 羁绊ID
     * @return Result 包含具有指定羁绊的所有英雄关系
     */
    @GetMapping("/bond/{bondId}")
    public Result getByBondId(@PathVariable Integer bondId) {
        // 查询具有指定羁绊的所有英雄关系
        List<HerosBond> herosBonds = herosBondService.list(
                new QueryWrapper<HerosBond>()
                        .eq("bond_id", bondId)  // 筛选指定羁绊ID的英雄关系
        );
        return new Result(true, "查询成功", herosBonds);
    }

    /**
     * 根据名称搜索英雄羁绊关系
     * 请求路径: GET /heros-bond/search?keyword=关键字
     * @param keyword 搜索关键字
     * @return Result 包含匹配的英雄羁绊关系及其详细信息
     */
    @GetMapping("/search")
    public Result searchByName(@RequestParam String keyword) {
        // 搜索匹配的英雄羁绊关系（根据关系名称模糊匹配）
        List<HerosBond> herosBonds = herosBondService.list(
                new QueryWrapper<HerosBond>()
                        .like("name", keyword)  // 关系名称匹配关键字
        );

        // 为每个结果添加详细信息
        List<Map<String, Object>> detailedResults = new ArrayList<>();
        for (HerosBond hb : herosBonds) {
            Map<String, Object> result = new HashMap<>();

            // 获取英雄详细信息
            Heros hero = herosService.getById(hb.getHeroId());

            // 获取羁绊详细信息
            Bond bond = bondService.getById(hb.getBondId());

            // 构造包含详细信息的结果
            result.put("relation", hb);        // 英雄羁绊关系基本信息
            result.put("heroDetail", hero);    // 英雄详细信息
            result.put("bondDetail", bond);    // 羁绊详细信息

            detailedResults.add(result);
        }

        return new Result(true, "查询成功", detailedResults);
    }


    /**
     * 获取所有英雄羁绊关系及其详细信息
     * 请求路径: GET /heros-bond/details
     * @return Result 包含所有英雄羁绊关系的详细信息
     */
    @GetMapping("/details")
    public Result listWithDetails() {
        List<Map<String, Object>> detailedResults = new ArrayList<>();

        // 查询所有羁绊
        List<Bond> bondList = bondService.list();
        // 获取羁绊详细信息
        bondList.stream().forEach(bond -> {
            // 查询与当前羁绊相关的英雄关系
            List<HerosBond> herosBonds = herosBondService.list(new LambdaQueryWrapper<HerosBond>().eq(HerosBond::getBondId, bond.getId()));

            // 限制每个羁绊只显示前2个相关英雄
            herosBonds.stream().limit(2).forEach(hb -> {
                Integer heroId = hb.getHeroId();
                Heros heros = herosService.getById(heroId);

                Map<String, Object> result = new HashMap<>();
                // 构造包含详细信息的结果
                result.put("heroDetail", heros);   // 英雄详细信息
                result.put("bondDetail", bond);    // 羁绊详细信息
                detailedResults.add(result);
            });

        });

        /*List<HerosBond> herosBonds = herosBondService.list();

        // 为每个结果添加详细信息
        List<Map<String, Object>> detailedResults = new ArrayList<>();
        for (HerosBond hb : herosBonds) {
            // 获取羁绊详细信息
            Bond bond = bondService.getById(hb.getBondId());
            // 获取英雄详细信息
            Heros hero = herosService.getById(hb.getHeroId());

            Map<String, Object> result = new HashMap<>();
            // 构造包含详细信息的结果
            result.put("relation", hb);
            result.put("heroDetail", hero);
            result.put("bondDetail", bond);

            detailedResults.add(result);
        }*/

        return new Result(true, "查询成功", detailedResults);
    }
}
